Apprendre Java en 10 minutes

9 July 2025 — Langage De Programmation

Java est un langage de programmation orienté objet de haut niveau connu pour son principe “écrire une fois, exécuter partout”. Ce tutoriel couvre les fonctionnalités de Java 21+, vous aidant à apprendre rapidement les fondamentaux de Java.

1. Écrire votre premier programme Java

Les programmes Java sont organisés en classes. Commençons par un programme simple. Créez un fichier nommé HelloWorld.java :

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

Compilez et exécutez le programme :

javac HelloWorld.java
java HelloWorld

Le résultat sera :

Hello, World!

Ce programme simple démontre la structure de base de Java. Chaque programme Java doit avoir au moins une classe, et la méthode main est le point d’entrée.

2. Syntaxe de base

La syntaxe Java est structurée et suit des règles spécifiques :

// Ceci est un commentaire d'une ligne
/* Ceci est un
   commentaire multiligne */

public class BasicSyntax {
    public static void main(String[] args) {
        System.out.println("Hello, Java!");
    }
}

Règles de syntaxe de base en Java :

Sensibilité à la casse : Java est sensible à la casse. Variable et variable sont différents.
Noms de classes : Doivent commencer par une lettre majuscule et suivre la convention CamelCase.
Noms de méthodes : Doivent commencer par une lettre minuscule et suivre la convention camelCase.
Points-virgules : Chaque instruction doit se terminer par un point-virgule ;.
Accolades : Les blocs de code sont définis avec des accolades {}.
Commentaires : Les commentaires d’une ligne utilisent //, les commentaires multilignes utilisent /* */.

3. Variables et types de données

Java est un langage statiquement typé, ce qui signifie que vous devez déclarer explicitement les types de variables.

Règles de nommage des variables :

Doit commencer par une lettre, un underscore _, ou un signe dollar $.
Peut contenir des lettres, des chiffres, des underscores et des signes dollar.
Ne peut pas être des mots-clés Java.
Doit suivre la convention camelCase.

Types de données primitifs de Java :

byte : entier signé 8 bits (-128 à 127)
short : entier signé 16 bits (-32,768 à 32,767)
int : entier signé 32 bits (-2^31 à 2^31-1)
long : entier signé 64 bits (-2^63 à 2^63-1)
float : virgule flottante 32 bits
double : virgule flottante 64 bits
boolean : true ou false
char : caractère Unicode 16 bits

public class DataTypes {
    public static void main(String[] args) {
        // Types entiers
        byte age = 25;
        short year = 2024;
        int population = 1000000;
        long distance = 93000000L; // suffixe L pour long
        
        // Types à virgule flottante
        float temperature = 36.5f; // suffixe f pour float
        double pi = 3.14159265359;
        
        // Booléen et caractère
        boolean isActive = true;
        char grade = 'A';
        
        // Chaîne (type de référence)
        String name = "Alice";
        
        System.out.println("Name: " + name + ", Age: " + age);
    }
}

3.1 Opérations sur les chaînes

Les chaînes en Java sont des objets, pas des types primitifs :

public class StringExample {
    public static void main(String[] args) {
        String text = "Java Programming";
        
        System.out.println("Length: " + text.length());
        System.out.println("Uppercase: " + text.toUpperCase());
        System.out.println("Lowercase: " + text.toLowerCase());
        System.out.println("Character at index 0: " + text.charAt(0));
        System.out.println("Substring: " + text.substring(0, 4));
        System.out.println("Contains 'Java': " + text.contains("Java"));
        
        // Concaténation de chaînes
        String greeting = "Hello, " + "World!";
        System.out.println(greeting);
        
        // Formatage de chaînes
        String formatted = String.format("Pi is approximately %.2f", 3.14159);
        System.out.println(formatted);
    }
}

4. Tableaux et collections

4.1 Tableaux

Les tableaux stockent plusieurs valeurs du même type :

public class ArrayExample {
    public static void main(String[] args) {
        // Déclaration et initialisation de tableau
        int[] numbers = {1, 2, 3, 4, 5};
        String[] fruits = new String[3];
        fruits[0] = "apple";
        fruits[1] = "banana";
        fruits[2] = "orange";
        
        // Accès aux éléments du tableau
        System.out.println("First number: " + numbers[0]);
        System.out.println("Array length: " + numbers.length);
        
        // Itération à travers les tableaux
        for (int i = 0; i < numbers.length; i++) {
            System.out.println("Number " + i + ": " + numbers[i]);
        }
        
        // Boucle for améliorée (for-each)
        for (String fruit : fruits) {
            System.out.println("Fruit: " + fruit);
        }
        
        // Tableaux multidimensionnels
        int[][] matrix = {{1, 2}, {3, 4}, {5, 6}};
        System.out.println("Matrix element [1][1]: " + matrix[1][1]);
    }
}

4.2 Collections

Le Java Collections Framework fournit des structures de données dynamiques :

import java.util.*;

public class CollectionsExample {
    public static void main(String[] args) {
        // ArrayList (tableau dynamique)
        ArrayList<String> names = new ArrayList<>();
        names.add("Alice");
        names.add("Bob");
        names.add("Charlie");
        names.remove("Bob");
        System.out.println("Names: " + names);
        
        // HashMap (paires clé-valeur)
        HashMap<String, Integer> ages = new HashMap<>();
        ages.put("Alice", 25);
        ages.put("Bob", 30);
        ages.put("Charlie", 35);
        System.out.println("Alice's age: " + ages.get("Alice"));
        
        // HashSet (éléments uniques)
        HashSet<Integer> uniqueNumbers = new HashSet<>();
        uniqueNumbers.add(1);
        uniqueNumbers.add(2);
        uniqueNumbers.add(2); // Doublon, ne sera pas ajouté
        uniqueNumbers.add(3);
        System.out.println("Unique numbers: " + uniqueNumbers);
        
        // Itération à travers les collections
        for (String name : names) {
            System.out.println("Name: " + name);
        }
        
        for (Map.Entry<String, Integer> entry : ages.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
    }
}

5. Opérations et opérateurs

Java fournit divers opérateurs pour différentes opérations :

Opérateurs arithmétiques : +, -, *, /, % (modulo), ++ (incrément), -- (décrément)
Opérateurs de comparaison : ==, !=, >, <, >=, <=
Opérateurs logiques : && (et), || (ou), ! (non)
Opérateurs bitwise : &, |, ^, ~, <<, >>, >>>
Opérateurs d’affectation : =, +=, -=, *=, /=, %=

public class OperatorsExample {
    public static void main(String[] args) {
        int a = 10, b = 3;
        
        // Opérations arithmétiques
        System.out.println("Addition: " + (a + b));
        System.out.println("Subtraction: " + (a - b));
        System.out.println("Multiplication: " + (a * b));
        System.out.println("Division: " + (a / b));
        System.out.println("Modulus: " + (a % b));
        
        // Incrément et décrément
        System.out.println("Pre-increment: " + (++a));
        System.out.println("Post-decrement: " + (b--));
        
        // Opérations de comparaison
        System.out.println("Equal: " + (a == b));
        System.out.println("Not equal: " + (a != b));
        System.out.println("Greater than: " + (a > b));
        
        // Opérations logiques
        boolean x = true, y = false;
        System.out.println("AND: " + (x && y));
        System.out.println("OR: " + (x || y));
        System.out.println("NOT: " + (!x));
        
        // Opérations d'affectation
        int c = 5;
        c += 3; // c = c + 3
        System.out.println("After += 3: " + c);
    }
}

6. Flux de contrôle

6.1 Instructions conditionnelles

public class ConditionalExample {
    public static void main(String[] args) {
        int score = 85;
        
        // instruction if-else
        if (score >= 90) {
            System.out.println("Grade: A");
        } else if (score >= 80) {
            System.out.println("Grade: B");
        } else if (score >= 70) {
            System.out.println("Grade: C");
        } else {
            System.out.println("Grade: F");
        }
        
        // Opérateur ternaire
        String result = (score >= 60) ? "Pass" : "Fail";
        System.out.println("Result: " + result);
        
        // instruction switch
        char grade = 'B';
        switch (grade) {
            case 'A':
                System.out.println("Excellent!");
                break;
            case 'B':
                System.out.println("Good!");
                break;
            case 'C':
                System.out.println("Average");
                break;
            default:
                System.out.println("Invalid grade");
        }
    }
}

6.2 Boucles

public class LoopExample {
    public static void main(String[] args) {
        // boucle for
        System.out.println("For loop:");
        for (int i = 0; i < 5; i++) {
            System.out.println("Iteration: " + i);
        }
        
        // Boucle for améliorée (for-each)
        System.out.println("\nFor-each loop:");
        int[] numbers = {1, 2, 3, 4, 5};
        for (int num : numbers) {
            System.out.println("Number: " + num);
        }
        
        // boucle while
        System.out.println("\nWhile loop:");
        int count = 0;
        while (count < 3) {
            System.out.println("Count: " + count);
            count++;
        }
        
        // boucle do-while
        System.out.println("\nDo-while loop:");
        int x = 0;
        do {
            System.out.println("X: " + x);
            x++;
        } while (x < 3);
        
        // break et continue
        System.out.println("\nBreak and continue:");
        for (int i = 0; i < 10; i++) {
            if (i == 5) {
                break; // Sortir de la boucle
            }
            if (i % 2 == 0) {
                continue; // Ignorer les nombres pairs
            }
            System.out.println("Odd number: " + i);
        }
    }
}

7. Méthodes (fonctions)

Les méthodes en Java sont des fonctions qui appartiennent aux classes :

public class MethodExample {
    
    // Méthode sans paramètres et sans valeur de retour
    public static void greet() {
        System.out.println("Hello, World!");
    }
    
    // Méthode avec paramètres et valeur de retour
    public static int add(int a, int b) {
        return a + b;
    }
    
    // Méthode avec plusieurs paramètres
    public static String formatName(String firstName, String lastName) {
        return firstName + " " + lastName;
    }
    
    // Surcharge de méthode (même nom, paramètres différents)
    public static int multiply(int a, int b) {
        return a * b;
    }
    
    public static double multiply(double a, double b) {
        return a * b;
    }
    
    // Arguments variables (varargs)
    public static int sum(int... numbers) {
        int total = 0;
        for (int num : numbers) {
            total += num;
        }
        return total;
    }
    
    public static void main(String[] args) {
        greet();
        
        int result = add(5, 3);
        System.out.println("Addition result: " + result);
        
        String fullName = formatName("John", "Doe");
        System.out.println("Full name: " + fullName);
        
        System.out.println("Multiply integers: " + multiply(4, 5));
        System.out.println("Multiply doubles: " + multiply(2.5, 3.0));
        
        System.out.println("Sum of multiple numbers: " + sum(1, 2, 3, 4, 5));
    }
}

8. Programmation orientée objet

8.1 Classes et objets

public class Person {
    // Variables d'instance (champs)
    private String name;
    private int age;
    private String email;
    
    // Constructeur
    public Person(String name, int age, String email) {
        this.name = name;
        this.age = age;
        this.email = email;
    }
    
    // Constructeur par défaut
    public Person() {
        this("Unknown", 0, "");
    }
    
    // Méthodes getter
    public String getName() {
        return name;
    }
    
    public int getAge() {
        return age;
    }
    
    public String getEmail() {
        return email;
    }
    
    // Méthodes setter
    public void setName(String name) {
        this.name = name;
    }
    
    public void setAge(int age) {
        if (age >= 0) {
            this.age = age;
        }
    }
    
    public void setEmail(String email) {
        this.email = email;
    }
    
    // Méthode d'instance
    public void introduce() {
        System.out.println("Hi, I'm " + name + ", " + age + " years old.");
    }
    
    // Méthode avec logique
    public boolean isAdult() {
        return age >= 18;
    }
    
    // Méthode toString (surcharge du toString d'Object)
    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + ", email='" + email + "'}";
    }
    
    public static void main(String[] args) {
        // Création d'objets
        Person person1 = new Person("Alice", 25, "[email protected]");
        Person person2 = new Person();
        
        // Utilisation des méthodes
        person1.introduce();
        System.out.println("Is adult: " + person1.isAdult());
        
        person2.setName("Bob");
        person2.setAge(17);
        person2.setEmail("[email protected]");
        
        System.out.println(person1.toString());
        System.out.println(person2.toString());
    }
}

Ce tutoriel Java complet couvre les concepts essentiels nécessaires pour commencer avec la programmation Java. Le typage fort du langage, les fonctionnalités orientées objet et la vaste bibliothèque standard le rendent puissant pour construire des applications robustes. Pratiquez ces exemples et expérimentez avec le code pour approfondir votre compréhension des concepts de programmation Java.